package gruppenkalenderProjekt;

import gruppenkalenderProjekt.data.Benutzer;
import gruppenkalenderProjekt.data.BenutzerImpl;
import gruppenkalenderProjekt.data.Kalender;
import gruppenkalenderProjekt.data.KalenderImpl;
import gruppenkalenderProjekt.data.Kalendereintrag;
import gruppenkalenderProjekt.data.KalendereintragImpl;
import gruppenkalenderProjekt.data.Kategorie;
import gruppenkalenderProjekt.data.KategorieImpl;
import gruppenkalenderProjekt.db.BenutzerMapper;
import gruppenkalenderProjekt.db.KalenderMapper;
import gruppenkalenderProjekt.db.KalendereintragMapper;
import gruppenkalenderProjekt.db.KategorieMapper;
import java.awt.Color;
import java.rmi.RemoteException;
import java.sql.Date;
import java.sql.Time;
import java.util.Vector;

/**
 * Implementierungsklasse des Interface <code>Verwaltung</code>.
 * Diese Klasse verwaltet den Zugriff auf die Mapper des Projektes
 * @see Verwaltung
 * @author Rathke, Thies
 * @coauthor Gruppe2
 */
// <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
// #[regen=yes,id=DCE.8A0BA1A6-4F15-A4B4-5EBE-CA451702F115]
// </editor-fold> 
public class VerwaltungImpl extends java.rmi.server.UnicastRemoteObject
        implements Verwaltung {

    /**Konstruktor, dem alle Mapper übergeben werden
     *
     * @param kalendermapper Objekt vom Typ KalenderMapper
     * @param kalendereintragmapper Objekt vom Typ KalereintragMapper
     * @param kategoriemapper Objekt vom Typ KatergorieMapper
     * @param benutzermapper Objekt vom Typ BenutzerMapper
     * @throws RemoteException
     */
    public VerwaltungImpl(KalenderMapper kalendermapper, KalendereintragMapper kalendereintragmapper,
            KategorieMapper kategoriemapper, BenutzerMapper benutzermapper) throws RemoteException {
        super();

        this.kalendermapper = kalendermapper;
        this.kalendereintragMapper = kalendereintragmapper;
        this.kategorieMapper = kategoriemapper;
        this.benutzermapper = benutzermapper;

    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.A0387DF0-7F40-EE70-B480-EC5E5B7646AA]
    // </editor-fold> 
    // private Kalender kalender;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.4A09723C-03A9-5062-9350-390CE37E2626]
    // </editor-fold> 
    private BenutzerMapper benutzermapper;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.D8DCD4AA-1BCA-DCB6-CF3E-D79E4CB23480]
    // </editor-fold> 
    private KalendereintragMapper kalendereintragMapper;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.919DDDA2-9C3B-A08F-4A91-2E7AF3691FB8]
    // </editor-fold> 
    private KalenderMapper kalendermapper;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.0B0A481A-45E8-6401-8A03-D369E90EC1F5]
    // </editor-fold> 
    private KategorieMapper kategorieMapper;

    /**Methode erstellt einen Benutzer
     *
     * @param benutzername der Benutzername
     * @param vorname der Vorname
     * @param nachname der Nachname
     * @param raum der Raum
     * @param email die Email
     * @param telefon der Telefon
     * @param superbenutzer ist der Benutzer ein Superbenutzer (wenn ja, dann true)
     * @throws RemoteException
     * @return benutzer der angelegte Benutzer
     */
    @Override
    public Benutzer createBenutzer(String benutzername, String vorname, String nachname,
            String raum, String email, String telefon, boolean superbenutzer) throws RemoteException {

        //neues Benutzer Objekt vom Typ BenutzerImpl anlegen und alle Parameter setzen
        Benutzer benutzer = new BenutzerImpl();
        benutzer.setBenutzername(benutzername);
        benutzer.setVorname(vorname);
        benutzer.setNachname(nachname);
        benutzer.setRaum(raum);
        benutzer.setEmail(email);
        benutzer.setTelefon(telefon);
        benutzer.setSuperbenutzer(superbenutzer);


        //Benutzer Objekt wird an den benutzermapper übergeben und speichert in dessen Methode den Benutzer
        //in die Datenbank. Dort wird automatisch eine ID vergeben und diese wird im Objekt gespeichert und dann
        //zurückgegeben, letztendlich gibt dieses return das vollstaendige Objekt (mit ID) zurück.
        return this.benutzermapper.insert(benutzer);
    }

    /**Methode aendert einen Benutzer
     *
     * @param benutzer der geaenderte Benutzer
     * @throws RemoteException
     * @return benutzer der geaenderte Benutzer
     */
    @Override
    public Benutzer updateBenutzer(Benutzer benutzer) throws RemoteException {
        return this.benutzermapper.update(benutzer); //benutzer Objekt an Mapper weitergeben um es in der DB zu aktualisieren
    }

    /**Methode loescht einen Benutzer
     *
     * @param benutzer der zu loeschende Benutzer
     * @throws RemoteException
     */
    @Override
    public void deleteBenutzer(Benutzer benutzer) throws RemoteException {

        this.benutzermapper.delete(benutzer); //benutzer Objekt an Mapper weitergeben um es aus der DB zu loeschen


    }

    /**Methode gibt alle Benutzer zurueck
     *
     * @return
     * @throws RemoteException
     */
    @Override
    public Vector<Benutzer> getAlleBenutzer() throws RemoteException {
        return this.benutzermapper.findeAlleBenutzer();
    }

    /**Gibt den Benutzer mit der angegebenen ID zurück
     *
     * @param b_id die ID des Benutzers
     * @return
     * @throws RemoteException
     */
    @Override
    public Benutzer getBenutzerMitID(int b_id) throws RemoteException {
        return this.benutzermapper.findeBenutzerMitID(b_id);
    }

    /**Methode erstellt eine Kategorie
     *
     * @param bezeichnung die Bezeichnung
     * @param farbe die Color
     * @throws RemoteException
     * @return kategorie die angelegte Kategorie
     */
    @Override
    public Kategorie createKategorie(String bezeichnung, Color farbe) throws RemoteException {

        //neues Kategorie Objekt vom Typ KategorieImpl anlegen und alle Parameter setzen
        Kategorie kategorie = new KategorieImpl();
        kategorie.setBezeichnung(bezeichnung);
        kategorie.setFarbe(farbe);


        //Kategorie Objekt wird an den kategorieermapper übergeben und speichert in dessen Methode die Kategorie
        //in die Datenbank. Dort wird automatisch eine ID vergeben und diese wird im Objekt gespeichert und dann
        //zurückgegeben, letztendlich gibt dieses return das vollstaendige Objekt (mit ID) zurück.
        return this.kategorieMapper.insert(kategorie);
    }

    /**Methode aendert eine Kategorie
     *
     * @param kategorie die geaenderte Kategorie
     * @throws RemoteException
     * @return kategorie die geaenderte Kategorie
     */
    @Override
    public Kategorie updateKategorie(Kategorie kategorie) throws RemoteException {

        return this.kategorieMapper.update(kategorie); //kategorie Objekt an Mapper weitergeben um es in der DB zu aktualisieren

    }

    /**Methode loescht eine Kategorie
     *
     * @param kategorie
     * @throws RemoteException
     */
    @Override
    public void deleteKategorie(Kategorie kategorie) throws RemoteException {

        this.kategorieMapper.delete(kategorie); //kategorie Objekt an Mapper weitergeben um es aus der DB zu loeschen
    }

    /**Methode gibt alle Kategorien zurueck
     *
     * @return
     * @throws RemoteException
     */
    @Override
    public Vector<Kategorie> getAlleKategorien() throws RemoteException {
        return this.kategorieMapper.findeAlleKategorien();
    }

    /**Gibgt die Kategorie mit der übergebenen ID zurück
     *
     * @param kat_ID die ID der Kategorie
     * @return
     * @throws RemoteException
     */
    @Override
    public Kategorie getKategorieMitID(int kat_ID) throws RemoteException {
        return this.kategorieMapper.findeKategorieMitID(kat_ID);
    }

    /**Methode erstellt einen Kalender
     *
     * @param name der Kalendernname
     * @param kalendereinträge die Kalendereinträge (Achtung Vektor)
     * @param Vector<Benutzer> der/die Benutzer (Achtung Vektor)
     * @param benutzer der Besitzer
     * @throws RemoteException
     * @return Kalender der angelegte Kalender
     */
    @Override
    public Kalender createKalender(String name, Vector<Kalendereintrag> kalendereintraege,
            Vector<Benutzer> benutzer, Benutzer besitzer) throws RemoteException {

        //neues Kalender Objekt vom Typ KalenderImpl anlegen und alle Parameter setzen
        Kalender kalender = new KalenderImpl();
        kalender.setName(name);
        kalender.setKalendereintraege(kalendereintraege);
        kalender.setBenutzer(benutzer);
        kalender.setBesitzer(besitzer);

        //Kalender Objekt wird an den kalendermapper übergeben und speichert in dessen Methode den Kalender
        //in die Datenbank. Dort wird automatisch eine ID vergeben und diese wird im Objekt gespeichert und dann
        //zurückgegeben, letztendlich gibt dieses return das vollstaendige Objekt (mit ID) zurück.
        return this.kalendermapper.insert(kalender);
    }

    /**Methode aktualisiert einen Kalender
     *
     * @param kalender der zu aktualisierende Kalnder (incl. aller KAlendereinträge, teilnehmer usw.)
     * @return
     * @throws RemoteException
     */
    @Override
    public Kalender updateKalender(Kalender kalender) throws RemoteException {
        //wenn Kalendereintraege existieren, werden zuerst diese Upgedatet
        if (kalender.getKalendereintraege() != null) {
            for (int i = 0; i < kalender.getKalendereintraege().size(); i++) {
                this.updateKalendereintrag(kalender.getKalendereintraege().elementAt(i));
            }
        }
        return this.kalendermapper.update(kalender); //kalender Objekt an Mapper weitergeben um es in der DB zu aktualisieren
    }

    /**Methode loescht einen Kalender
     *
     * @param kalender der zu loeschende Kalender
     * @throws RemoteException
     */
    @Override
    public void deleteKalender(Kalender kalender) throws RemoteException {

        //besitz loeschen
        this.kalendermapper.deleteBesitzerVonKalender(kalender);
        //zugehoerigkeit loeschen
        this.kalendermapper.deleteAlleBenutzerVonKalender(kalender);
        //kalendereintraege loeschen
        if (kalender.getKalendereintraege() != null) {
            for (int i = 0; i < kalender.getKalendereintraege().size(); i++) {
                this.deleteKalendereintrag(kalender.getKalendereintraege().elementAt(i));
            }
        }
        //kalender loeschen - erledigt
        this.kalendermapper.delete(kalender); //kalender Objekt an Mapper weitergeben um es aus der DB zu loeschen
    }

    /**Methode gibt alle Kalender zurueck
     *
     * @return k Alle Kalender
     * @throws RemoteException
     */
    @Override
    public Vector<Kalender> getAlleKalender() throws RemoteException {

        Vector<Kalender> k = this.kalendermapper.findeAlleKalender(); //Alle Kalender aus der DB abfragen
        for (int i = 0; i < k.size(); i++) {
            k.elementAt(i).setBesitzer(this.benutzermapper.findeBesitzerVonKalender(
                    k.elementAt(i).getKalenderID())); //Jedem Kalender seinen Besitzer zuordnen
            k.elementAt(i).setBenutzer(this.benutzermapper.findeBenutzerVonKalender(
                    k.elementAt(i).getKalenderID())); //Jedem Kalender seine Benutzer zuordnen
            k.elementAt(i).setKalendereintraege(this.getKalendereintraegeVonKalender(
                    k.elementAt(i).getKalenderID())); //Jedem Kalender werden die zugehoerigen Kalendereintraege zurueckgegeben
        }


        return k;
    }

    /**Methode erstellt einen Kalendereintrag
     *
     * @param titel der Titel
     * @param kategorie die Kategorie
     * @param ersteller der Ersteller
     * @param beschreibung die Beschreibung
     * @param ort der Ort
     * @param stratdatum das Startdatum
     * @param startzeit die Stratzeit
     * @param enddatumm das Enddatum
     * @param endzeit die Endzeit
     * @param erinnerung Erinnerung(ja/nein)
     * @param zeitdifferenz die Zeitdifferenz
     * @param alarm der Alarma(ja/nein)
     * @param teilnehmer die Teilnehmer (Achtung Vektor)
     * @param folgetermin die Folgetermine
     * @param wiederholung die Wiederholung
     * @throws RemoteException
     * @return kalendereintarg der angelegte Kalendereintrag
     */
    @Override
    public Kalendereintrag createKalendereintrag(String titel, Kategorie kategorie,
            Benutzer ersteller, String beschreibung, String ort, Date startdatum,
            Time startzeit, Date enddatum, Time endzeit, boolean erinnerung,
            int zeitdifferenz, boolean alarm, Vector<Benutzer> teilnehmer,
            Kalendereintrag folgetermin, int kalender_ID, int wiederholung) throws RemoteException {

        Kalendereintrag kalendereintrag = new KalendereintragImpl();
        kalendereintrag.setTitel(titel);
        kalendereintrag.setKategorie(kategorie);
        kalendereintrag.setErsteller(ersteller);
        kalendereintrag.setBeschreibung(beschreibung);
        kalendereintrag.setOrt(ort);
        kalendereintrag.setStartdatum(startdatum);
        kalendereintrag.setStartzeit(startzeit);
        kalendereintrag.setEnddatum(enddatum);
        kalendereintrag.setEndzeit(endzeit);
        kalendereintrag.setErinnerung(erinnerung);
        kalendereintrag.setZeitdifferenzErinnerung(zeitdifferenz);
        kalendereintrag.setAlarm(alarm);
        kalendereintrag.setTeilnehmer(teilnehmer);
        kalendereintrag.setFolgetermin(folgetermin);
        kalendereintrag.setKalenderID(kalender_ID);
        kalendereintrag.setWiederholung(wiederholung);


        kalendereintrag = this.kalendereintragMapper.insert(kalendereintrag);
        //Benutzer Objekt wird an den benutzermapper übergeben und speichert in dessen Methode den Benutzer
        //in die Datenbank. Dort wird automatisch eine ID vergeben und diese wird im Objekt gespeichert und dann
        //zurückgegeben, letztendlich gibt dieses return das vollstaendige Objekt (mit ID) zurück.

        return kalendereintrag;

    }

    /*aktualisiert einen Kalendereintrag
     *
     * @param kalendereintrag der zu aendernde Kalendereintrag
     * @return
     * @throws RemoteException
     */
    @Override
    public Kalendereintrag updateKalendereintrag(Kalendereintrag kalendereintrag) throws RemoteException {

        return this.kalendereintragMapper.update(kalendereintrag); //kalendereintrag Objekt an Mapper weitergeben um es in der DB zu aktualisieren

    }

    /**loescht einen Kalendereintrag
     *
     * @param kalendereintrag der zu loeschende Kalendereintrag
     * @throws RemoteException
     */
    @Override
    public void deleteKalendereintrag(Kalendereintrag kalendereintrag) throws RemoteException {
        //ersteller aus erstellung loeschen - erledigt
        this.kalendereintragMapper.deleteErstellerVonKalendereintrag(kalendereintrag);

        //Teilnehmer aus Sichtbarkeit loeschen - erledigt
        this.kalendereintragMapper.deleteAlleTeilnehmerVonKalendereintrag(kalendereintrag);

        //Kalendereintrag an sich loeschen - erledigt
        this.kalendereintragMapper.delete(kalendereintrag); //kalendereintrag Objekt an Mapper weitergeben um es aus der DB zu loeschen
    }

    /**gibt alle Kalendereintraege zurueck
     *
     * @return k alle Kalendereintraege
     * @throws RemoteException
     */
    @Override
    public Vector<Kalendereintrag> getAlleKalendereintraege() throws RemoteException {
        Vector<Kalendereintrag> k = this.kalendereintragMapper.findeAlleKalendereintraege();
        for (int i = 0; i < k.size(); i++) {
            k.setElementAt(this.getKalendereintragMitID(k.elementAt(i).getKalendereintragID()), i);
        }
        return k;
    }

    /**Gibt alle Kalendereintraege eines Benutzers zurueck
     * 
     * @param b_ID die ID des Benutzers
     * @return result Alle Kalendereintraege des Benutzers
     * @throws RemoteException
     */
    @Override
    public Vector<Kalendereintrag> getAlleKalendereintraegeVonBenutzer(int b_ID) throws RemoteException {
        //alle Kalendereintraege holen
        Vector<Kalendereintrag> result = this.kalendereintragMapper.findeAlleKalendereintragVonBenutzer(b_ID);
        //Wenn Kalendereintraege existieren werden diese Objekte vervollständigt
        // (Also Ersteller und Teilnehmer und KAtegorie hinzugefuegt)       
        if (result == null) {
            return null;
        }
        for (int i = 0; i < result.size(); i++) {
            if (result == null) {

                result.setElementAt(this.getKalendereintragMitID(result.elementAt(i).getKalendereintragID()), i);
                return null;
            }
        }
        return result;
    }

    /**Gibt den Kalendereintrag mit der angegebenen ID zurueck
     *
     * @param e_ID Kalendereintrags_ID
     * @return k Kalendereintrag mit der uebergebenen ID
     * @throws RemoteException
     */
    @Override
    public Kalendereintrag getKalendereintragMitID(int e_ID) throws RemoteException {
        Kalendereintrag k = this.kalendereintragMapper.findeKalendereintragMitID(e_ID);
        k.setKategorie(this.kategorieMapper.findeKategorieVonKalendereintrag(e_ID));
        k.setErsteller(this.benutzermapper.findeErstellerVonKalendereintrag(e_ID));
        k.setTeilnehmer(this.benutzermapper.findeTeilnehmerVonKalendereintrag(e_ID));


        return k;
    }

    /** Gibt alle Kalendereintraege eines Kalenders zurueck
     *
     * @param k_ID ID des Kalenders
     * @return k alle Kalendereintraege eines Kalenders
     * @throws RemoteException
     */
    @Override
    public Vector<Kalendereintrag> getKalendereintraegeVonKalender(int k_ID) throws RemoteException {
        //alle Kalendereinträge holen
        Vector<Kalendereintrag> k = this.kalendereintragMapper.findeKalendereintraegeVonKalender(k_ID);
        //Objekte Vervollständigen (Ersteller, Teilnehmer etc. hinzufuegen)
        for (int i = 0; i < k.size(); i++) {
            k.setElementAt(this.getKalendereintragMitID(k.elementAt(i).getKalendereintragID()), i);
        }
        return k;
    }

    /** Gibt alle Kalendereintraege eines Kalenders von einem Benutzer zurueck
     *
     * @param k_ID ID des Kalenders
     * @return k alle Kalendereintraege eines Kalenders
     * @throws RemoteException
     */
    @Override
    public Vector<Kalendereintrag> getKalendereintraegeVonKalenderVonBenutzer(int k_ID, int b_ID) throws RemoteException {
        //alle Kalendereinträge holen
        Vector<Kalendereintrag> k = this.kalendereintragMapper.findeAlleKalendereintragVonBenutzerInKalender(b_ID, k_ID);
        //Objekte Vervollständigen (Ersteller, Teilnehmer etc. hinzufuegen)
        for (int i = 0; i < k.size(); i++) {
            k.setElementAt(this.getKalendereintragMitID(k.elementAt(i).getKalendereintragID()), i);
        }
        return k;
    }

    /** Methode gibt alle Kalender eines Benutzers zurück
     *
     * @param b_id die ID des Benutzers
     * @return ergebnis alle Kalender des Benutzers
     * @throws RemoteException
     */
    @Override
    public Vector<Kalender> getAlleKalenderVonSuperbenutzer(int b_id) throws RemoteException {

        /*Es wird ein Kalenderobjekt welche der mitgegebenen Benutzer_ID entsprechen
         * in den Vektor ergebnis geschrieben. In der Datenbank sind jedoch in der Tabelle
         * Kalender nur die Attribute K_id und name gespeichert. Es soll jedoch ein vollständiges
         * Kalednerobjekt zurückgebene werden. Es fehlen die Attribute: kalendereinträge, benutzer
         * und besitzer. (Welche auf Objektebene dazugehören)
         */
        Vector<Kalender> ergebnis = this.kalendermapper.getAlleKalendervonBenutzer(b_id);
        /*Um das Kalenderobjekt zu vervollstäbdigen wird die Methode getKalenderMitID aufgerufen und
         * dieser wird beim ersten Aufruf die Kalender id welche an erster Stelle steht mitgegeben.
         * Zurück kommt ein vollständiges Kalenderobjekt mit den fehlenden Attributen kalendereinträge,
         *benutzer und besitzer. Das unvollständige Objekt an dieser Stelle wird durch das vollständige
         * überschrieben
         */
        for (int i = 0; i < ergebnis.size(); i++) {
            ergebnis.setElementAt(this.getKalenderMitID(ergebnis.elementAt(i).getKalenderID()), i);

        }

        return ergebnis;

    }

    /**Gibt den Kalender mit der angegebenen ID zurueck
     *
     * @param k_ID Kalender_ID
     * @return k Kalender mit uebergebener ID
     * @throws RemoteException
     */
    @Override
    public Kalender getKalenderMitID(int k_ID) throws RemoteException {
        Kalender k = this.kalendermapper.findeKalenderMitID(k_ID);
        k.setKalendereintraege(this.getKalendereintraegeVonKalender(k_ID));
        k.setBenutzer(this.benutzermapper.findeBenutzerVonKalender(k_ID));
        k.setBesitzer(this.benutzermapper.findeBesitzerVonKalender(k_ID));

        return k;
    }

    /**Gibt den Kalender mit der angegebenen ID zurueck und fügt nur die Kalender
     * einträge bei denen ein Benutzer teilnimmt hinzu
     *
     * @param k_ID Kalender_ID
     * @return k Kalender mit uebergebener ID
     * @throws RemoteException
     */
    public Kalender getKalenderMitIDVonBenutzer(int k_ID, int b_ID) throws RemoteException {
        Kalender k = this.kalendermapper.findeKalenderMitID(k_ID);

        k.setKalendereintraege(this.getKalendereintraegeVonKalenderVonBenutzer(k_ID, b_ID));
        k.setBenutzer(this.benutzermapper.findeBenutzerVonKalender(k_ID));
        k.setBesitzer(this.benutzermapper.findeBesitzerVonKalender(k_ID));

        return k;
    }

    /**Gibt den Benutzer mit dem angegebenen Benutzername zurueck
     *
     * @param benutzername der Benutzername des Benutzers
     * @return
     * @throws RemoteException
     */
    @Override
    public Benutzer getBenutzerMitBenutzername(String benutzername) throws RemoteException {
        return this.benutzermapper.findeBenutzerMitBenutzername(benutzername);
    }

    /**Gibt alle Benutzer eines Kalenders zurück
     *
     * @param k_ID ID des Kalenders
     * @return
     * @throws RemoteException
     */
    @Override
    public Vector<Benutzer> getBenutzerVonKalender(int k_ID) throws RemoteException {
        return this.benutzermapper.findeBenutzerVonKalender(k_ID);
    }

    /**Methode uberprueft, ob die Startzeit des Kalendereintrags zulaessig ist
     *
     * @param k der Zu pruefende Kalendereintrag
     * @return true, wenn erlaubt. false, wenn nicht erlaubt
     * @throws RemoteException
     */
    @Override
    public boolean isKalendereintragStartzeitZulaessig(Kalendereintrag k) throws RemoteException {
        if (k.getStartdatum().before(k.getEnddatum())) {
            return true;
        }
        if (k.getStartdatum().equals(k.getEnddatum())) {
            if (k.getStartzeit().before(k.getEndzeit()) || k.getStartzeit().equals(k.getEndzeit())) {
                return true;
            }

        }
        return false;
    }

    /**Methode gibt alles Kalender eines Benutzers zurueck
     *
     * @param b_id ID des Benutzers
     * @return ergebnis Der Vector mit allen Elementen
     * @throws RemoteException
     */
    @Override
    public Vector<Kalender> getAlleKalenderVonBenutzer(int b_id) throws RemoteException {

        Vector<Kalender> ergebnis = this.kalendermapper.getAlleKalendervonBenutzer(b_id);
        /*Um das Kalenderobjekt zu vervollstäbdigen wird die Methode getKalenderMitID aufgerufen und
         * dieser wird beim ersten Aufruf die Kalender id welche an erster Stelle steht mitgegeben.
         * Zurück kommt ein vollständiges Kalenderobjekt mit den fehlenden Attributen kalendereinträge,
         *benutzer und besitzer. Das unvollständige Objekt an dieser Stelle wird durch das vollständige
         * überschrieben
         */
        for (int i = 0; i < ergebnis.size(); i++) {
            ergebnis.setElementAt(this.getKalenderMitIDVonBenutzer(ergebnis.elementAt(i).getKalenderID(), b_id), i);
        }

        return ergebnis;
    }

    /**Methode prueft ob ein Benutzer mit einem Benutzername bereits existiert
     *
     * @param benutzername der Benutzername
     * @param aktuellerBenutzer der eingeloggte Benutzer
     * @return
     * @throws RemoteException
     */
    @Override
    public boolean existiertBenutzerMitBenutzername(String benutzername, Benutzer aktuellerBenutzer) throws RemoteException {

        Vector<Benutzer> tempBenutzer = this.getAlleBenutzer();
        //abfrage ob der Benutzername bereits existiert
        for (Benutzer b : tempBenutzer) {
            if (b.getBenutzername().toLowerCase().equals(benutzername.toLowerCase())) {
                if (!aktuellerBenutzer.getBenutzername().toLowerCase().equals(benutzername.toLowerCase())) {
                    return true;
                }
            }
        }

        return false;
    }
}

